home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / smail-3.1.28 / util / mkline.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-11  |  4.1 KB  |  242 lines
  1. /* @(#)util/mkline.c    1.3 7/11/92 11:40:08 */
  2.  
  3. /*
  4.  *    Copyright (C) 1987, 1988 Ronald S. Karr and Landon Curt Noll
  5.  *    Copyright (C) 1992  Ronald S. Karr
  6.  * 
  7.  * See the file COPYING, distributed with smail, for restriction
  8.  * and warranty information.
  9.  */
  10.  
  11. /*
  12.  * mkline.c:
  13.  *    Take an alias, pathalias or similarly formed file and collapse
  14.  *    into single-line records with comments stripped.
  15.  */
  16. #include <stdio.h>
  17. #include <ctype.h>
  18. #include <sys/types.h>
  19. #include <sys/stat.h>
  20. #include "defs.h"
  21. #include "smail.h"
  22. #include "extern.h"
  23. #include "field.h"
  24. #include "addr.h"
  25. #include "dys.h"
  26. #include "exitcodes.h"
  27.  
  28. char *program;                /* argv[0] from main */
  29. int debug = 0;
  30. FILE *errfile = stderr;
  31. int use_tabs_p = FALSE;
  32. int ignore_keys_p = FALSE;
  33.  
  34. /*ARGSUSED*/
  35. void
  36. main(argc, argv)
  37.     int argc;
  38.     char **argv;
  39. {
  40.     int list_files_p = FALSE;        /* TRUE for -l option */
  41.  
  42.     program = *argv++;
  43.  
  44.     /* if -l, process mailing list files */
  45.     while (*argv && (*argv)[0] == '-' && (*argv)[1] != '\0') {
  46.     register char *p;
  47.  
  48.     for (p = *argv + 1; *p; p++) {
  49.         switch (*p) {
  50.         case 'l':
  51.         list_files_p = TRUE;
  52.         break;
  53.  
  54.         case 't':
  55.         use_tabs_p = TRUE;
  56.         break;
  57.  
  58.         case 'n':
  59.         ignore_keys_p = TRUE;
  60.         break;
  61.  
  62.         default:
  63.         (void) fprintf(stderr, "Usage: %s [-ltn] [file ...]\n",
  64.                    program);
  65.         exit(EX_USAGE);
  66.         }
  67.     }
  68.     argv++;
  69.     }
  70.  
  71.     if (*argv == NULL) {
  72.     if ((list_files_p? mklistline(stdin): mkaliasline(stdin)) < 0) {
  73.         exit(EX_DATAERR);
  74.     }
  75.     }
  76.     while (*argv) {
  77.     FILE *f;
  78.  
  79.     if (EQ(*argv, "-")) {
  80.         f = stdin;
  81.     } else {
  82.         f = fopen(*argv, "r");
  83.         if (f == NULL) {
  84.         (void) fprintf(stderr, "%s: cannot open %s: ", program, *argv);
  85.         perror("");
  86.         exit(errno);
  87.         }
  88.     }
  89.     if ((list_files_p? mklistline(f): mkaliasline(f)) < 0) {
  90.         exit(EX_DATAERR);
  91.     }
  92.     argv++;
  93.     }
  94.  
  95.     exit(0);
  96. }
  97.  
  98. mkaliasline(f)
  99.     FILE *f;
  100. {
  101.     char *s;
  102.  
  103.     /*
  104.      * read an entry of the form:
  105.      *
  106.      *        name:value
  107.      *  or    name value
  108.      */
  109.     while (s = read_entry(f)) {
  110.     register char *sp = s;
  111.     char *error;
  112.     struct token *tokens;
  113.     register struct token *toks;
  114.  
  115.     if (! ignore_keys_p) {
  116.         while (!isspace(*sp) && *sp != ':') {
  117.         sp++;
  118.         }
  119.  
  120.         /* split the line in two */
  121.         *sp++ = '\0';
  122.     }
  123.  
  124.     /* turn it into tokens */
  125.     error = tokenize(sp, &tokens, TRUE, TRUE);
  126.  
  127.     if (error) {
  128.         (void) fprintf(stderr, "%s: tokenize error: %s\n", program, error);
  129.         return -1;
  130.     }
  131.  
  132.     if (! ignore_keys_p) {
  133.         /* write out the name */
  134.         printf((use_tabs_p? "%s\t": "%s:"), s);
  135.     }
  136.  
  137.     /* write out the data, with most white space squeezed out */
  138.     for (toks = tokens; toks; toks = toks->succ) {
  139.         fputs(toks->text, stdout);
  140.         if ((QUOTETOK(toks->form) || TEXTTOK(toks->form)) &&
  141.         toks->succ &&
  142.         (QUOTETOK(toks->succ->form) || TEXTTOK(toks->succ->form)))
  143.         {
  144.         putchar(' ');
  145.         }
  146.     }
  147.     putchar('\n');
  148.     }
  149.  
  150.     return 0;
  151. }
  152.  
  153. mklistline(f)
  154.     register FILE *f;
  155. {
  156.     struct str s;
  157.     register int c;
  158.     char *error = NULL;
  159.     struct addr *list = NULL;
  160.     struct addr *cur;
  161.  
  162.     STR_INIT(&s);
  163.     while ((c = getc(f)) != EOF) {
  164.     STR_NEXT(&s, c);
  165.     }
  166.     STR_NEXT(&s, '\0');
  167.     (void) process_field(NULL, s.p, NULL, NULL, &list, F_ALIAS, &error);
  168.     if (error) {
  169.     (void) fprintf(stderr, "%s: %s\n", program, error);
  170.     return -1;
  171.     }
  172.  
  173.     for (cur = list; cur; cur = cur->succ) {
  174.     printf("%s\n", cur->in_addr);
  175.     }
  176.  
  177.     return 0;
  178. }
  179.  
  180. /*
  181.  * standalone versions of some referenced routines
  182.  */
  183. char *
  184. xmalloc(len)
  185.     int len;
  186. {
  187.     char *malloc();
  188.     register char *ret = malloc(len);
  189.  
  190.     if (ret == NULL) {
  191.     (void) fprintf(stderr, "%s: out of memory!\n", program);
  192.     }
  193.     return ret;
  194. }
  195.  
  196. char *
  197. xrealloc(s, len)
  198.     char *s;
  199.     int len;
  200. {
  201.     char *realloc();
  202.     register char *ret = realloc(s, len);
  203.  
  204.     if (ret == NULL) {
  205.     (void) fprintf(stderr, "%s: out of memory!\n", program);
  206.     }
  207.     return ret;
  208. }
  209.  
  210. void
  211. xfree(s)
  212.     char *s;
  213. {
  214.     free(s);
  215. }
  216.  
  217. /*ARGSUSED*/
  218. char *
  219. qualify_domain(s)
  220.     char *s;
  221. {
  222.     return NULL;
  223. }
  224.  
  225. struct addr *
  226. alloc_addr()
  227. {
  228.     register struct addr *ret = (struct addr *)xmalloc(sizeof(struct addr));
  229.  
  230.     bzero((char *)ret, sizeof(struct addr));
  231.     return ret;
  232. }
  233.  
  234. /*ARGSUSED*/
  235. char *
  236. preparse_address(s, error)
  237.     char *s;
  238.     char **error;
  239. {
  240.     return s;
  241. }
  242.